\chapter{Protocollo}
\label{chap:protocollo}
	Il sistema è stato pensato per garantire confidenzialità nella comunicazione in un sistema 
	peer-to-peer in cui ciascun membro dispone di una coppia di chiavi pubblica e privata 
	opportunamente certificata. In particolare, la comunicazione tra i peer è preceduta dall' 
	esecuzione del protocollo per stabilire una chiave di sessione. Tale protocollo garantisce 
	\emph{key authentication} (ovvero, ogni peer crede che la chiave stabilita sia la chiave
	di sessione), \emph{key confirmation} (ovvero, ogni peer crede che la controparte sia
	convinta sulla key authentication relativamente alla chiave di sessione) e infine
	\emph{key freshness} (si garantisce che entrambe le parti siano convinte della freschezza
	della chiave di sessione generata).
	Viene illustrato, qui di seguito, il protocollo:
	\[
		\begin{aligned}
			M1:\ & A \rightarrow B & & C_A\\
			M2:\ & A \leftarrow B & & C_B\\
			M3:\ & A \rightarrow B & & \encrypt{n_A}{\publickey{B}}\\
			M4:\ & A \leftarrow B & & \encrypt{n_A,\ n_B}{\publickey{A}}\\
			M5:\ & A \rightarrow B & & \encrypt{n_B}{\publickey{B}}\\
		\end{aligned}
	\]
	Significato dei messaggi:
	\begin{description}
		\item[M1]: $A$ invia a $B$ il proprio certificato $C_A$;
		\item[M2]: avendo verificato la validità del certificato di $A$, $B$ invia a $A$ il proprio certificato $C_B$;
		\item[M3]: avendo verificato la validità del certificato di $B$, $A$ genera un nonce random $n_A$ e lo invia
		cifrandolo con la chiave pubblica di $B$. In questo modo, solamente B potrà leggere $M3$;
		\item[M4]: $B$ decifra il nonce con la sua chiave privata, a sua volta crea un nonce random $n_B$ ed invia
		ad $A$ $n_A$ ed $n_B$ cifrando il messaggio con la chiave pubblica di $A$. In questo modo, solo $A$ potrà 
		leggere $M4$;
		\item[M5]: $A$ decifra il nonce $n_A$ e controlla che corrisponda a quello che ha inviato. In caso affermativo,
		reinvia a $B$ il nonce $n_B$, dopo averlo decifrato con la sua chiave privata. Infine, $A$ genera la chiave di sessione.
		$B$ verifica che il nonce $n_B$ ricevuto corrisponda a quello precedente inviato. In tal caso, procede a generare la chiave di sessione.
	\end{description}

	La chiave di sessione viene generata a partire dai nonce $n_A$ ed $n_B$. In questo modo entrambe le parti partecipano
	alla creazione della chiave, quindi non è necessario che i peer facciano assunzioni sulla capacità
	della controparte di generare nonce realmente freschi.
	L'algoritmo di generazione della chiave di sessione è il seguente:
	\[
		\begin{cases}
			y = h ( n_A || n_B )\\
			K_{AB} =  \overleftarrow{T_{128bit}}(y)
		\end{cases}
	\]
	dove per $\overleftarrow{T_{128bit}}(y)$ si intende il troncamento di $y$ ai suoi $128\ bit$ più significativi.
\clearpage{\pagestyle{empty}\cleardoublepage}
